package com.exonline.front.controller.courses;

import cn.hutool.core.util.IdUtil;

import com.exonline.commons.base.IBaseServlet;
import com.exonline.commons.utils.QiNiuUploadUtils;
import com.exonline.commons.utils.TokenUtils;
import com.exonline.commons.entity.Courses;
import com.exonline.commons.entity.Direction;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.apache.commons.fileupload.FileItem;
import org.apache.commons.fileupload.disk.DiskFileItemFactory;
import org.apache.commons.fileupload.servlet.ServletFileUpload;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.File;
import java.io.IOException;
import java.io.PrintWriter;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
 * @desc : 课程管理 的C层
 * @author : hbrj
 */
@WebServlet("/font/courses")
public class CoursesServlet  extends HttpServlet implements IBaseServlet {
    // 使用Jackson库进行JSON格式的响应输出
    ObjectMapper mapper = new ObjectMapper();
    // 课程类，用于处理课程相关业务逻辑
    CoursesService service = new CoursesService();
    // 七牛云上传工具类
    static QiNiuUploadUtils qiNiuUploadUtils = new QiNiuUploadUtils();
    // 上传配置
    private static final int MEMORY_THRESHOLD   = 1024 * 1024 * 3;
    private static final int MAX_FILE_SIZE      = 1024 * 1024 * 40;
    private static final int MAX_REQUEST_SIZE   = 1024 * 1024 * 1024 ;
    // 分页 默认页数
    int pageno = 1;
    /**
     * @desc  处理客户端发来的HTTP请求，依据请求中的method参数，调用不同的操作方法。
     *        支持的操作有：查询课程(查询全部和结构化查询)、添加课程、编辑课程、删除课程、排行榜的查询
     *        课程收藏(添加和查询), 课程搜索(模糊查询: 1表示按课程名模糊查询，2表示按科目模糊查询)
     *
     * @param req  客户端请求
     * @param resp 服务端响应
     * @throws ServletException 如果请求处理过程中发生错误
     * @throws IOException 如果响应过程中发生I/O错误
     */
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 获取请求参数中的method值
         String method = req.getParameter("method");
         // 获取请求参数中的页码，用于分页查询
         if (req.getParameter("pageno") != null){
             pageno = Integer.parseInt(req.getParameter("pageno"));
         }
                 try {
                     //直接查课程,返回课程列表
                     if ("queryall".equals(method)) {
                         this.query(req, resp);
                     } else if("structurequery".equals(method)){
                         this.structurequery(req,resp);
                     } else if ("queryone".equals(method)) {
                         this.queryOne(req, resp);
                     } else if ("add".equals(method)) {
                         this.add(req, resp);
                     } else if ("edit".equals(method)) {
                         this.edit(req, resp);
                     } else if ("delete".equals(method)) {
                         this.delete(req, resp);
                     } else if ("tquery".equals(method)) {
                         this.tquery(req,resp);
                     } else if ("leaderboard".equals(method)) {
                         this.leaderboard(req,resp);
                     } else if ("individualcoursequery".equals(method)) {
                         this.individualcoursequery(req,resp);
                     } else if ("newcouarsequery".equals(method)) {
                         this.newcouarsequery(req,resp);
                     } else if ("addcollect".equals(method)){
                         this.addcollect(req,resp);
                     } else if ("collect".equals(method)) {
                         this.collect(req,resp);
                     } else if ("search".equals(method)) {
                         this.search(req,resp);
                     }
                 } catch (Exception e) {
                     throw new ServletException(e);
                 };
    }

    /**
     * @desc  1. 查询课程信息
     * @param req  请求参数
     * @param resp 响应数据
     * @throws SQLException 如果数据库查询出错
     * @throws IOException 如果响应过程中发生I/O错误
     */
    @Override
    public void query(HttpServletRequest req, HttpServletResponse resp) throws SQLException, IOException {
        String condition = req.getParameter("condition");
        List<Courses> courses = service.queryAll(condition,10, pageno);
        Map<String, Object> map = new HashMap<>();
        map.put("code", 200);
        map.put("msg", "查询成功");
        map.put("data", courses);
        mapper.writeValue(resp.getWriter(), map);
    }


    /**
     * @desc  2. 课程的结构化查询  分成( 方向 科目 课程 )
     * @param req  请求参数
     * @param resp 响应数据
     * @throws SQLException 如果数据库查询出错
     * @throws IOException 如果响应过程中发生I/O错误
     */
    private void structurequery(HttpServletRequest req, HttpServletResponse resp) throws SQLException, IOException {
        String condition = req.getParameter("condition");
        List<Direction> directions = service.structurequery(condition, 12, pageno);
        Map<String, Object> map = new HashMap<>();
        map.put("code", 200);
        map.put("msg", "结构化查询成功");
        map.put("data", directions);
        mapper.writeValue(resp.getWriter(), map);
    }


    /**
     * @desc  3. 查询单个课程
     * @param req  请求参数
     * @param resp 响应数据
     * @throws SQLException 如果数据库查询出错
     * @throws IOException 如果响应过程中发生I/O错误
     */
    @Override
    public void queryOne(HttpServletRequest req, HttpServletResponse resp) throws SQLException, IOException {
        String id = req.getParameter("id");
        Courses courses = service.queryOne(id);
        Map<String, Object> map = new HashMap<>();
        map.put("code", 200);
        map.put("msg", "查询成功");
        map.put("data", courses);
        mapper.writeValue(resp.getWriter(), map);
    }

    /**
     * @desc  13. 根据课程名称进行模糊查询
     * @author hbrj
     * @param req  请求参数
     * @param resp 响应数据
     */
    private void search(HttpServletRequest req, HttpServletResponse resp) {
        try {
            // 1. 获取前端传递的查询参数（课程名或者科目名），假设参数名为 "queryValue"，可根据实际调整
            String queryValue = req.getParameter("queryValue");
            // 2. 获取前端传递的查询类型参数，假设参数名为 "queryType"，1表示按课程名模糊查询，2表示按科目模糊查询，可根据实际调整
            String queryTypeStr = req.getParameter("queryType");
            // 3. 校验查询参数是否为空，如果为空则返回错误信息
            if (queryValue == null || queryValue.trim().isEmpty() || queryTypeStr == null) {
                Map<String, Object> map = new HashMap<>();
                map.put("code", 400);
                map.put("msg", "请输入有效的查询值和查询类型进行查询");
                map.put("data", null);
                mapper.writeValue(resp.getWriter(), map);
                return;
            }
            // 4. 将查询类型字符串转换为整数
            int queryType = Integer.parseInt(queryTypeStr);

            // 5. 获取Service实例（这里假设已经在类中正确初始化了service对象）
            CoursesService service = new CoursesService();

            // 6. 调用Service层的方法进行模糊查询，根据不同的查询类型传递相应参数
            List<Courses> courses = service.searchCoursesByName(queryValue, queryType);

            Map<String, Object> resultMap = new HashMap<>();
            resultMap.put("code", 200);
            resultMap.put("msg", "查询成功");
            resultMap.put("data", courses);

            // 7. 将查询结果转换为JSON格式并写入响应
            mapper.writeValue(resp.getWriter(), resultMap);
        } catch (IOException e) {
            e.printStackTrace();
            try {
                Map<String, Object> errorMap = new HashMap<>();
                errorMap.put("code", 500);
                errorMap.put("msg", "查询过程中出现错误");
                errorMap.put("data", null);
                mapper.writeValue(resp.getWriter(), errorMap);
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        } catch (NumberFormatException e) {
            e.printStackTrace();
            try {
                Map<String, Object> errorMap = new HashMap<>();
                errorMap.put("code", 400);
                errorMap.put("msg", "查询类型参数格式不正确");
                errorMap.put("data", null);
                mapper.writeValue(resp.getWriter(), errorMap);
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }
    }

    /**
     * @desc  11. 课程添加到收藏表
     * @author hbrj
     * @param req  请求参数
     * @param resp 响应数据
     */
    private void addcollect(HttpServletRequest req, HttpServletResponse resp) {
        try {
            // 1. 从Session中获取学生id
            String sid = TokenUtils.getId(req);

            // 2. 检查是否成功从Session获取到学生id，如果未获取到，返回错误信息
            if (sid == null) {
                Map<String, Object> map = new HashMap<>();
                map.put("code", 201);
                map.put("msg", "未能从Session中获取到学生id，请检查相关设置");
                map.put("data", null);
                mapper.writeValue(resp.getWriter(), map);
                return;
            }

            // 3. 获取当前课程的id（这里假设你有合适的方式从请求或者其他地方获取到当前课程的cid，比如从前端传来的参数等，示例中暂简单模拟获取）
            String cid = req.getParameter("cid");
            if (cid == null) {
                Map<String, Object> map = new HashMap<>();
                map.put("code", 202);
                map.put("msg", "未能从请求中获取到课程id，请检查前端参数传递");
                map.put("data", null);
                mapper.writeValue(resp.getWriter(), map);
                return;
            }

            // 4. 生成收藏记录的唯一标识（UUID），用于collect表的id字段
            String collectId = IdUtil.simpleUUID();

            // 5. 获取Service实例（这里假设已经在类中正确初始化了service对象）
            CoursesService service = new CoursesService();

            // 6. 调用Service层方法添加收藏记录，并获取该学生收藏的课程信息列表（以Map形式表示每条课程记录）
            boolean addCollectResult = service.addCollectRecord(collectId, sid, cid);
            if (!addCollectResult) {
                Map<String, Object> map = new HashMap<>();
                map.put("code", 500);
                map.put("msg", "添加收藏记录失败，请检查数据库操作或相关逻辑");
                map.put("data", null);
                mapper.writeValue(resp.getWriter(), map);
                return;
            }
            // 7. 获取该学生收藏的课程信息列表（以Map形式表示每条课程记录）
            List<Map<String, Object>> collectedCourses = service.getCollectedCourses(sid);
            Map<String, Object> resultMap = new HashMap<>();
            resultMap.put("code", 200);
            resultMap.put("msg", "收藏课程查询成功");
            resultMap.put("data", collectedCourses);

            // 8. 将收藏课程信息列表转换为JSON格式并写入响应
            mapper.writeValue(resp.getWriter(), resultMap);
        } catch (IOException e) {
            e.printStackTrace();
            try {
                Map<String, Object> errorMap = new HashMap<>();
                errorMap.put("code", 500);
                errorMap.put("msg", "收藏课程查询过程中出现错误");
                errorMap.put("data", null);
                mapper.writeValue(resp.getWriter(), errorMap);
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        } catch (SQLException e) {
            e.printStackTrace();
            try {
                Map<String, Object> errorMap = new HashMap<>();
                errorMap.put("code", 500);
                errorMap.put("msg", "数据库操作出现错误，请检查相关配置或SQL语句");
                errorMap.put("data", null);
                mapper.writeValue(resp.getWriter(), errorMap);
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }
    }

    /**
     * @desc  12. 个人中心 收藏课程查询
     * @author hbrj
     * @param req  请求参数
     * @param resp 响应数据
     */
    private void collect(HttpServletRequest req, HttpServletResponse resp) {
        try {
            // 1. 从Session中获取学生id
            String sid = TokenUtils.getId(req);

            // 2. 检查是否成功从Session获取到学生id，如果未获取到，返回错误信息
            if (sid == null) {
                Map<String, Object> map = new HashMap<>();
                map.put("code", 201);
                map.put("msg", "未能从Session中获取到学生id，请检查相关设置");
                map.put("data", null);
                mapper.writeValue(resp.getWriter(), map);
                return;
            }

            // 3. 获取Service实例（这里假设已经在类中正确初始化了service对象）
            CoursesService service = new CoursesService();

            // 4. 调用Service层方法获取该学生收藏的课程信息列表（以Map形式表示每条课程记录）
            List<Map<String, Object>> collectedCourses = service.getCollectedCourses(sid);
            Map<String, Object> resultMap = new HashMap<>();
            resultMap.put("code", 200);
            resultMap.put("msg", "收藏课程查询成功");
            resultMap.put("data", collectedCourses);

            // 5. 将收藏课程信息列表转换为JSON格式并写入响应
            mapper.writeValue(resp.getWriter(), resultMap);
        } catch (IOException e) {
            e.printStackTrace();
            try {
                Map<String, Object> errorMap = new HashMap<>();
                errorMap.put("code", 500);
                errorMap.put("msg", "收藏课程查询过程中出现错误");
                errorMap.put("data", null);
                mapper.writeValue(resp.getWriter(), errorMap);
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }
    }

    /**
     * @desc  10. 新课推荐的查询
     * @author hbrj
     * @param req  请求参数
     * @param resp 响应数据
     */
    private void newcouarsequery(HttpServletRequest req, HttpServletResponse resp) {
        try {
            // 1. 获取Service实例（这里假设已经在类中正确初始化了service对象）
            CoursesService service = new CoursesService();

            // 2. 调用Service层方法获取新课推荐课程信息列表（以Map形式表示每条课程记录）
            List<Direction> newCourses = service.getNewCourses();
            Map<String, Object> resultMap = new HashMap<>();
            resultMap.put("code", 200);
            resultMap.put("msg", "新课推荐查询成功");
            resultMap.put("data", newCourses);

            // 3. 将新课推荐课程信息列表转换为JSON格式并写入响应
            mapper.writeValue(resp.getWriter(), resultMap);
            // 4. 处理异常
        } catch (IOException | SQLException e) {
            e.printStackTrace();
            try {
                Map<String, Object> errorMap = new HashMap<>();
                errorMap.put("code", 500);
                errorMap.put("msg", "新课推荐查询过程中出现错误");
                errorMap.put("data", null);
                mapper.writeValue(resp.getWriter(), errorMap);
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }
    }

    /**
     * @desc  9. 个人中心的学习记录查询
     * @author hbrj
     * @param req  请求参数
     * @param resp 响应数据
     */
    private void individualcoursequery(HttpServletRequest req, HttpServletResponse resp) {
        try {
            // 1. 从Session中获取学生id
             String studentId = TokenUtils.getId(req);

            // 2. 检查是否成功从Session获取到学生id，如果未获取到，返回错误信息
            if (studentId == null) {
                Map<String, Object> map = new HashMap<>();
                map.put("code", 201);
                map.put("msg", "未能从Session中获取到学生id，请检查相关设置");
                map.put("data", null);
                mapper.writeValue(resp.getWriter(), map);
                return;
            }

            // 3. 获取Service实例（这里假设已经在类中正确初始化了service对象）
            CoursesService service = new CoursesService();

            // 4. 根据学生id获取该学生学习的课程信息列表（以Map形式表示每条课程记录）
            List<Map<String, Object>> courses = service.getIndividualCourses(studentId);
            Map<String, Object> resultMap = new HashMap<>();
            resultMap.put("code", 200);
            resultMap.put("msg", "查询学生个人学习课程成功");
            resultMap.put("data", courses);

            // 5. 将课程信息列表转换为JSON格式并写入响应
            mapper.writeValue(resp.getWriter(), resultMap);
        } catch (IOException | SQLException e) {
            e.printStackTrace();
            try {
                Map<String, Object> errorMap = new HashMap<>();
                errorMap.put("code", 500);
                errorMap.put("msg", "查询学生个人学习课程过程中出现错误");
                errorMap.put("data", null);
                mapper.writeValue(resp.getWriter(), errorMap);
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }

    }

    /**
     * @desc  8. 排行榜查询, (1. 畅销榜， 2. 学习榜)
     * @author hbrj
     * @param req  请求参数
     * @param resp 响应数据
     */
    private void leaderboard(HttpServletRequest req, HttpServletResponse resp) {
        try {
            // 1. 获取请求中的榜单类型参数（假设名为 boardType）
            String boardType = req.getParameter("boardType");

            // 2. 获取Service实例（这里假设已经在类中正确初始化了service对象）
            CoursesService service = new CoursesService();

            // 3. 根据榜单类型获取相应榜单数据
            List<Map<String, Object>> boardData = service.getBoardData(boardType);
            Map<String, Object> resultMap = new HashMap<>();
               //3.1 畅销榜 查询成功
            if ("best_selling".equals(boardType)) {
                resultMap.put("code", 200);
                resultMap.put("msg", "畅销榜查询成功");
               //3.2 学习榜 查询成功
            } else if ("most_studied".equals(boardType)) {
                resultMap.put("code", 200);
                resultMap.put("msg", "学习榜查询成功");
                //3.3  榜单类型无效
            } else {
                resultMap.put("code", 400);
                resultMap.put("msg", "无效的榜单类型参数");
                mapper.writeValue(resp.getWriter(), resultMap);
                return;
            }
            resultMap.put("data", boardData);

            // 4. 将榜单数据转换为JSON格式并写入响应
            mapper.writeValue(resp.getWriter(), resultMap);
            // 5. 处理异常
        } catch (IOException | SQLException e) {
            e.printStackTrace();
            try {
                Map<String, Object> errorMap = new HashMap<>();
                errorMap.put("code", 500);
                errorMap.put("msg", "查询排行榜过程中出现错误");
                errorMap.put("data", null);
                mapper.writeValue(resp.getWriter(), errorMap);
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }
    }

    /**
     * @desc  7. 教师端课程信息的查询
     * @author hbrj
     */
    private void tquery(HttpServletRequest req, HttpServletResponse resp) {
        try {
            // 7.1从Session中获取教师id
            String tid = TokenUtils.getId(req);

            // 7.2检查是否成功从Session获取到tid，如果未获取到，返回错误信息
            if (tid == null) {
                Map<String, Object> map = new HashMap<>();
                map.put("code", 201);
                map.put("msg", "未能从Session中获取到教师id，请检查相关设置");
                map.put("data", null);
                mapper.writeValue(resp.getWriter(), map);
                return;
            }
            // 执行查询
            List<Map<String, Object>> queryResult = service.tqueryById(tid);
            Map<String, Object> map = new HashMap<>();
            map.put("code", 200);
            map.put("msg", "查询成功");
            map.put("data", queryResult);
            mapper.writeValue(resp.getWriter(), map);
        } catch (IOException e) {
            e.printStackTrace();
            try {
                Map<String, Object> map = new HashMap<>();
                map.put("code", 500);
                map.put("msg", "查询过程中出现错误");
                map.put("data", null);
                mapper.writeValue(resp.getWriter(), map);
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * @desc  6. 课程信息的删除
     * @param req
     * @param resp
     * @throws SQLException
     * @throws IOException
     */
    @Override
    public void delete(HttpServletRequest req, HttpServletResponse resp) throws SQLException, IOException {
        // 获取课程id
        String id = req.getParameter("id");
        service.deleteById(id);
         Map<String, Object> map = new HashMap<>();
                 map.put("code", 200);
                 map.put("msg", "删除成功");
                 map.put("data", id);
                 mapper.writeValue(resp.getWriter(), map);
    }


    /**
     * @desc  4. 课程信息的添加
     * @param req  请求参数
     * @param resp 响应数据
     * @throws SQLException 如果数据库查询出错
     * @throws IOException 如果响应过程中发生I/O错误
     */
    @Override
    public void add(HttpServletRequest req, HttpServletResponse resp) throws SQLException, IOException {
        // 生成课程id
        String id = IdUtil.simpleUUID();
        // 从Session中获取教师id
        String tid = TokenUtils.getId(req);
        if (tid == null) {
            // 如果未能从Session获取到tid，直接返回错误信息给前端
            Map<String, Object> errorMap = new HashMap<>();
            errorMap.put("code", 201);
            errorMap.put("msg", "未能从Session中获取到tid，请检查相关设置");
            errorMap.put("data", null);
            // 将错误信息转换为JSON格式并写入响应
            mapper.writeValue(resp.getWriter(), errorMap);
            return;
        }
        // 从请求参数中获取其他课程信息 传入相关的参数
        String level = req.getParameter("clevel");
        String name = req.getParameter("cname");
        String introduce = req.getParameter("cintroduce");
        String price = req.getParameter("cprice");
        String direction = req.getParameter("cdirection");
        String subject = req.getParameter("csubject");

        // 调用doUrl方法处理cover封面图片的 上传等操作
        String url = doUrl(req, resp);
        // 如果doUrl执行成功（返回非null），继续执行添加操作
        if (url == null) {
            // 如果doUrl执行出现问题（返回null），说明文件上传等环节出错，返回相应错误信息给前端
            Map<String, Object> errorMap = new HashMap<>();
            errorMap.put("code", 500);
            errorMap.put("msg", "课程文件上传环节出现错误，请检查相关配置或重新尝试");
            errorMap.put("data", null);
            mapper.writeValue(resp.getWriter(), errorMap);
            return;
        }
        // 执行添加操作
        try {
            service.add(id, tid, url, 0, level, name, introduce, price, direction, subject, 0, 1);
            Map<String, Object> successMap = new HashMap<>();
            successMap.put("code", 200);
            successMap.put("msg", "添加成功");
            successMap.put("cid", id);
            mapper.writeValue(resp.getWriter(), successMap);
        } catch (SQLException e) {
            // 如果服务层的添加操作出现数据库相关异常，返回错误信息给前端
            Map<String, Object> errorMap = new HashMap<>();
            errorMap.put("code", 500);
            errorMap.put("msg", "课程信息添加到数据库时出现错误，请联系管理员");
            errorMap.put("data", null);
            mapper.writeValue(resp.getWriter(), errorMap);
            e.printStackTrace();
        }
    }

    /**
     * @desc  5. 编辑更改
     * @param req  请求参数
     * @param resp 响应数据
     * @throws SQLException 如果数据库查询出错
     * @throws IOException 如果响应过程中发生I/O错误
     */
    @Override
    public void edit(HttpServletRequest req, HttpServletResponse resp) throws SQLException, IOException {
        // 获取相关参数
        String id = req.getParameter("id");
        String tid = req.getParameter("tid");
        String level = req.getParameter("level");
        String name = req.getParameter("name");
        String introduce = req.getParameter("introduce");
        String price = req.getParameter("price");
        String direction = req.getParameter("direction");
        String subject = req.getParameter("subject");
        // 调用Service层方法进行更新
        service.update(id, tid, level, name, introduce, price, direction, subject);
        Map<String, Object> map = new HashMap<>();
        map.put("code", 200);
        map.put("msg", "修改成功");
        map.put("data", id+":"+name);
        mapper.writeValue(resp.getWriter(), map);
    }

    /**
     * @desc  上传的封面的图片资源
     * @param request
     * @param response
     * @return
     * @throws IOException
     */
    public static String doUrl(HttpServletRequest request, HttpServletResponse response) throws IOException {
        String url = "";
        {
            System.out.println(request.getParameter("id"));
            // 检测是否为多媒体上传
            if (!ServletFileUpload.isMultipartContent(request)) {
                // 如果不是则停止
                PrintWriter writer = response.getWriter();
                writer.println("Error: 表单必须包含 enctype=multipart/form-data");
                writer.flush();
                return null;
            }

            // 配置上传参数
            DiskFileItemFactory factory = new DiskFileItemFactory();
            // 设置内存临界值 - 超过后将产生临时文件并存储于临时目录中
            factory.setSizeThreshold(MEMORY_THRESHOLD);
            // 设置临时存储目录
            factory.setRepository(new File(System.getProperty("java.io.tmpdir")));

            ServletFileUpload upload = new ServletFileUpload(factory);

            // 设置最大文件上传值
            upload.setFileSizeMax(MAX_FILE_SIZE);

            // 设置最大请求值 (包含文件和表单数据)
            upload.setSizeMax(MAX_REQUEST_SIZE);

            // 中文处理
            upload.setHeaderEncoding("UTF-8");

            try {
                // 解析请求的内容提取文件数据
                @SuppressWarnings("unchecked")
                List<FileItem> formItems = upload.parseRequest(request);

                if (formItems!= null && formItems.size() > 0) {
                    // 迭代表单数据
                    for (FileItem item : formItems) {
                        // 处理不在表单中的字段
                        if (!item.isFormField()) {
                            // 上传文件到七牛云并获取返回的URL
                            url = qiNiuUploadUtils.uploadFiles(item.getInputStream(), item.getName());
                        }
                    }
                }
            } catch (Exception ex) {
                // 处理上传过程中出现的异常情况
                request.setAttribute("message", "错误信息: " + ex.getMessage());
                ex.printStackTrace();
                return null;
            }
        }
        return url;
    }
}
